diff --git a/user_guide/changelog.html b/user_guide/changelog.html
index dc3ddf3..57610ae 100644
--- a/user_guide/changelog.html
+++ b/user_guide/changelog.html
@@ -161,49 +161,55 @@
 <h3>Bug fixes for Version 1.6.0</h3>
 	
 <ul>
-	<li>Removed an extraneous call to loading models (#3286).</li>
-	<li>Removed extraneous load of $CFG in _display_cache() of the Output class (#3285).</li>
-	<li>Removed an unused parameter from Profiler (#3332).</li>
-	<li>Fixed a bug (#3284) where the rsegment array would not be set properly if the requested URI contained more segments than the routed URI.</li>
-	<li>Fixed a bug (#3314) which would cause the top level path to be deleted in delete_files() of the File helper.</li>
-	<li>Fixed a bug (#2858) which referenced a wrong variable in the Image class.</li>
-	<li>Fixed a bug (#3024) in which master_dim wasn't getting reset by clear() in the Image library.</li>
-	<li>Fixed a bug (#3330) in the FTP class where a comparison wasn't getting made.</li>
-	<li>Fixed a bug (#3328) where the smiley helper might return an undefined variable.</li>
-	<li>Fixed a bug (#3310) with sanitization of globals in the Input class that could unset CI's global variables.</li>
 	<li>Fixed a bug (#1890) in csv_from_result() where content that included the delimiter would break the file.</li>
-	<li>Fixed a bug (#3156) in Text Helper highlight_code() causing PHP tags to be handled incorrectly.</li>
-	<li>Fixed a bug (#3279) where the Email class was sending the wrong Content-Transfer-Encoding for some character sets.</li>
-    <li>Fixed a bug (#3268) where the Router could leave '/' as the path.</li>
-    <li>Fixed a series of grammatical and spelling errors in the language files.</li>
-    <li>Fixed a bug (#2974) in <kbd>highlight_phrase()</kbd> that caused an error with slashes.</li>
+	<li>Fixed a bug (#2542)in the clean_email() method of the Email class to allow for non-numeric / non-sequential array keys.</li>
+	<li>Fixed a bug (#2545) in <kbd>_html_entity_decode_callback()</kbd> when 'global_xss_filtering' is enabled.</li>
+	<li>Fixed a bug (#2668) in the <a href="./libraries/parser.html">parser class</a> where numeric data was ignored.</li>
+    <li>Fixed a bug (#2679) where the &quot;previous&quot; pagination link would get drawn on the first page.</li>
+</ul>
+
+
+
+
+<ul><li>Fixed a bug (#2702) in _object_to_array that broke some types of inserts and updates.</li>
+    <li>Fixed a bug (#2732) in the SQLite driver for PHP 4.</li>
+    <li>Fixed a bug (#2754) in Pagination to scan for non-positive num_links.</li>
+    <li>Fixed a bug (#2762) in the <a href="./libraries/sessions.html">Session library</a> where user agent matching would fail on user agents ending with a space. </li>
     <li>Fixed a bug (#2784) $field_names[] vs $Ffield_names[] in postgre and sqlite drivers.</li>
-    <li>Fixed a bug in the <a href="./libraries/file_uploading.html">upload library</a> when allowed_files wasn't defined.</li>
-    <li>Fixed a bug in <kbd>word_wrap()</kbd> of the Text Helper that incorrectly referenced an object. </li>
+    <li>Fixed a bug (#2810) in the typography helper causing extraneous paragraph tags when string contains tags.</li>
+    <li>Fixed a bug (#2858) which referenced a wrong variable in the Image class.</li>
+    <li>Fixed a bug (#2875)when loading plugin files as _plugin. and not _pi.</li>
+    <li>Fixed a bug (#2912) in <kbd>get_filenames()</kbd> in the <a href="./helpers/file_helper.html">File Helper </a>where the array wasn't cleared after each call.</li>
+    <li>Fixed a bug (#2974) in <kbd>highlight_phrase()</kbd> that caused an error with slashes.</li>
+    <li>Fixed a bug (#3003) in the Encryption Library to support modes other than MCRYPT_MODE_ECB</li>
+    <li>Fixed a bug (#3015) in the <a href="./libraries/user_agent.html">User Agent library</a> where more then 2 languages where not reported with languages().</li>
     <li>Fixed a bug (#3017) in the <a href="./libraries/email.html">Email</a> library where some timezones were calculated incorrectly. </li>
+    <li>Fixed a bug (#3024) in which master_dim wasn't getting reset by clear() in the Image library.</li>
+    <li>Fixed a bug (#3156) in Text Helper highlight_code() causing PHP tags to be handled incorrectly.</li>
+    <li>Fixed a bug (#3166) that prevented num_rows from working in Oracle.</li>
+    <li>Fixed a bug (#3175) preventing certain libraries from working properly when autoloaded in PHP 4.</li>
+    <li>Fixed a bug (#3267) in the Typography Helper where unordered list was listed &quot;un.</li>
+    <li>Fixed a bug (#3268) where the Router could leave '/' as the path.</li>
+    <li>Fixed a bug (#3279) where the Email class was sending the wrong Content-Transfer-Encoding for some character sets.</li>
+    <li>Fixed a bug (#3284) where the rsegment array would not be set properly if the requested URI contained more segments than the routed URI.</li>
+    <li>Removed extraneous load of $CFG in _display_cache() of the Output class (#3285).</li>
+    <li>Removed an extraneous call to loading models (#3286).</li>
+    <li>Fixed a bug (#3310) with sanitization of globals in the Input class that could unset CI's global variables.</li>
+    <li>Fixed a bug (#3314) which would cause the top level path to be deleted in delete_files() of the File helper.</li>
+    <li>Fixed a bug (#3328) where the smiley helper might return an undefined variable.</li>
+    <li>Fixed a bug (#3330) in the FTP class where a comparison wasn't getting made.</li>
+    <li>Removed an unused parameter from Profiler (#3332).</li>
+    <li>Fixed a bug in database driver where num_rows property wasn't getting updated.</li>
+    </ul>
+<ul><li>Fixed a bug in the <a href="./libraries/file_uploading.html">upload library</a> when allowed_files wasn't defined.</li>
+    <li>Fixed a bug in <kbd>word_wrap()</kbd> of the Text Helper that incorrectly referenced an object. </li>
     <li>Fixed a bug in <a href="./libraries/validation.html">Validation</a> where <kbd>valid_ip()</kbd> wasn't called properly.</li>
     <li>Fixed a bug in <a href="./libraries/validation.html">Validation</a> where individual error messages for checkboxes wasn't supported.</li>
-    <li>Fixed a bug (#3015) in the <a href="./libraries/user_agent.html">User Agent library</a> where more then 2 languages where not reported with languages().</li>
-    <li>Fixed a bug (#2762) in the <a href="./libraries/sessions.html">Session library</a> where user agent matching would fail on user agents ending with a space. </li>
-    <li>Fixed a bug in database driver where num_rows property wasn't getting updated.</li>
     <li>Fixed a bug in captcha calling an invalid PHP function.</li>
-    <li>Fixed a bug (#2545) in <kbd>_html_entity_decode_callback()</kbd> when 'global_xss_filtering' is enabled.</li>
-	<li>Fixed a bug in the cookie helper "set_cookie" function.  It was not honoring the config settings.</li>
+    <li>Fixed a bug in the cookie helper "set_cookie" function.  It was not honoring the config settings.</li>
     <li>Fixed a bug that was making validation callbacks required even when not set as such.</li>
-    <li>Fixed a bug (#2702) in _object_to_array that broke some types of inserts and updates.</li>
-    <li>Fixed a bug (#2912) in <kbd>get_filenames()</kbd> in the <a href="./helpers/file_helper.html">File Helper </a>where the array wasn't cleared after each call.</li>
-    <li>Fixed a bug (#3166) that prevented num_rows from working in Oracle.</li>
-    <li>Fixed a bug (#2668) in the <a href="./libraries/parser.html">parser class</a> where numeric data was ignored.</li>
-    <li>Fixed a bug (#2875)when loading plugin files as _plugin. and not _pi.</li>
-    <li>Fixed a bug (#2732) in the SQLite driver for PHP 4.</li>
-	<li>Fixed a bug (#2542)in the clean_email() method of the Email class to allow for non-numeric / non-sequential array keys.</li>
-    <li>Fixed a bug (#2754) in Pagination to scan for non-positive num_links.</li>
-	<li>Fixed a bug (#2810) in the typography helper causing extraneous paragraph tags when string contains tags.</li>
-	<li>Fixed a bug (#3003) in the Encryption Library to support modes other than MCRYPT_MODE_ECB</li>
-	<li>Fixed a bug (#3267) in the Typography Helper where unordered list was listed &quot;un&quot; (#3267)</li>
-	<li>Fixed a bug in the XML-RPC library so if a type is specified, a more intelligent decision is made as to the default type</li>
-	<li>Fixed a bug (#3175) preventing certain libraries from working properly when autoloaded in PHP 4</li>
-	<li>Fixed an example of comma-separated emails in the email library documentation.</li>
+    <li>Fixed a bug in the XML-RPC library so if a type is specified, a more intelligent decision is made as to the default type.</li>
+    <li>Fixed an example of comma-separated emails in the email library documentation.</li>
     <li>Fixed an example in the Calendar library for Showing Next/Previous Month Links.</li>
     <li>Fixed a typo in the database language file.</li>
     <li>Fixed a typo in the image language file &quot;suppor&quot; to &quot;support&quot;.</li>
@@ -213,12 +219,9 @@
     <li>Fixed a typo in the <a href="./helpers/string_helper.html">String Helper</a> (uniquid changed to uniqid).</li>
     <li>Fixed typos in the email Language class (email_attachment_unredable, email_filed_smtp_login), and FTP Class (ftp_unable_to_remame).</li>
     <li>Added a stripslashes()  into the Upload Library.</li>
+    <li>Fixed a series of grammatical and spelling errors in the language files.</li>
     <li>Fixed assorted user guide typos.</li>
 </ul>
-
-
-
-
 <h2>Version 1.5.4</h2>
 <p>Release Date: July 12, 2007 </p>
 <ul>
